#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdint.h>

#define BLOCK_SIZE 1024

// 定义超级块结构体
struct superblock {
    uint32_t s_inodes_count;
    uint32_t s_blocks_count;
    // 其他字段
    // ...
};

// 定义组描述符表结构体
struct group_descriptor {
    uint32_t bg_block_bitmap;
    uint32_t bg_inode_table;
    // 其他字段
    // ...
};

// 定义inode结构体
struct inode {
    uint16_t i_mode;
    uint32_t i_size;
    // 其他字段
    // ...
};

// 读取指定数据
void read_block(int fd, int block_num, void* buffer) {
    lseek(fd, block_num * BLOCK_SIZE, SEEK_SET);
    read(fd, buffer, BLOCK_SIZE);
}

// 解析超级块
void parse_superblock(struct superblock* sb, void* buffer) {
    sb->s_inodes_count = *((uint32_t*)(buffer + 0x00));
    sb->s_blocks_count = *((uint32_t*)(buffer + 0x04));
    // 解析其他字段
    // ...
}

// 解析组描述符表
void parse_group_descriptor(struct group_descriptor* gd, void* buffer) {
    gd->bg_block_bitmap = *((uint32_t*)(buffer + 0x00));
    gd->bg_inode_table = *((uint32_t*)(buffer + 0x04));
    // 解析其他字段
    // ...
}

// 解析位图
void parse_bitmap(void* buffer, int num_blocks) {
    int i, j;
    uint8_t* bitmap = (uint8_t*)buffer;

    for (i = 0; i < num_blocks / 8; i++) {
        for (j = 0; j < 8; j++) {
            if (bitmap[i] & (1 << j)) {
                printf("Block %d is allocated\n", i * 8 + j);
            } else {
                printf("Block %d is free\n", i * 8 + j);
            }
        }
    }
}



// 解析inode表项
void parse_inode(struct inode* inode, void* buffer) {
    inode->i_mode = *((uint16_t*)(buffer + 0x00));
    inode->i_size = *((uint32_t*)(buffer + 0x04));
    // 解析其他字段
    // ...
}

int main() {
    int fd;
    void* buffer;

    // 打开设备文件
    fd = open("/dev/vda", O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(1);
    }

    // 读取超级块
    buffer = malloc(BLOCK_SIZE);
    read_block(fd, 1, buffer);
    struct superblock sb;
    parse_superblock(&sb, buffer);

    // 读取组描述符表
    read_block(fd, 2, buffer);
    struct group_descriptor gd;
    parse_group_descriptor(&gd, buffer);

    // 读取位图
    printf("\nBitmap:\n");
    // 打印位图
    // ...

    buffer = malloc(BLOCK_SIZE);
    read_block(fd, 3, buffer);  // 假设位图在第3个数据块
    parse_bitmap(buffer, 8192);  // 假设文件系统有8192个数据块

    // 读取inode表项
    read_block(fd, gd.bg_inode_table, buffer);
    struct inode inode;
    parse_inode(&inode, buffer);

    // 打印解析结果
    printf("Superblock:\n");
    printf("Inodes count: %u\n", sb.s_inodes_count);
    printf("Blocks count: %u\n", sb.s_blocks_count);
    // 打印其他超级块字段
    // ...

    printf("\nGroup Descriptor:\n");
    printf("Block bitmap: %u\n", gd.bg_block_bitmap);
    printf("Inode table: %u\n", gd.bg_inode_table);
    // 打印其他组描述符表字段
    // ...

    printf("\nInode:\n");
    printf("Mode: %hu\n", inode.i_mode);
    printf("Size: %u\n", inode.i_size);
    // 打印其他inode字段
    // ...

    // 关闭设备文件
    close(fd);

    return 0;
}
